Expanded acyclic queries: Containment and an application in explaining missing answers

The first part of this thesis concerns the query containment problem, a fundamental static analysis problem in database theory. Given two queries in a language under consideration, the containment problem is to decide whether the answers of one query form a subset of the answers of the other one, over arbitrary databases. This problem finds applications in query optimization, query answering using views, query answering under constraints, etc. Because of its importance, the containment problem has been thoroughly studied for various query languages and data models in the past. In this thesis we continue to study the containment problem for various query languages over trees and relational databases that share one structural property — acyclicity. Namely, we consider: 1) Conjunctive and Positive Xpath queries interpreted on trees expanded with negation and attribute value comparisons; 2) Tree Patterns expanded with the conditional descendant axis, interpreted over trees; and 3) Acyclic conjunctive queries expanded with atomic negation and arithmetic comparisons over relational structures. We obtain complexity bounds for the containment problem for these languages. The second part of the dissertation proposes a new formal framework for why-not explanations. Our why-not explanations leverage concepts from an ontology to provide high-level and meaningful reasons for why certain data is missing from the result of a query. In this framework, we are interested in finding most general explanations relative to an ontology. We first address the problem of extracting an ontology from the database instance or schema. We show that this problem can be casted as the containment problem and provide the complexity analysis of it. Then we address the problem of computing a most general explanation. We study the complexity of this problem and associated problems, and present concrete algorithms for computing why-not explanations

Containment of acyclic conjunctive queries with negated atoms or arithmetic comparisons

We study the containment problem for conjunctive queries (CQs) expanded with negated atoms or arithmetic comparisons. It is known that the problem is Π2P-complete. The aim of this article is to find restrictions on CQs that allow for tractable containment. In particular, we consider acyclic conjunctive queries. Even with the most restrictive form of acyclicity (Berge-acyclicity), containment is coNP-hard. But for a particular fragment of Berge-acyclic CQs with negated atoms or arithmetic comparisons —child-only tree patterns— containment is solvable in PTime

Containment for queries over trees with attribute value comparisons

Björklund et al. showed that containment for conjunctive queries (CQ) over trees and positive XPath is respectively Π2P and coNP-complete. In this article we show that the same problem has the same complexity when we expand these languages with XPath׳s attribute value comparisons. We show that different restrictions on the domain of attribute values (finite, infinite, dense, discrete) have no impact on the complexity. Making attributes required does have an impact: the problem becomes harder. We also show that containment of tree patterns without the wildcard ⁎, which is in PTIME, becomes coNP-hard when adding equality and inequality comparisons

Entity comparison in RDF graphs

In many applications, there is an increasing need for the new types of RDF data analysis that are not covered by standard reasoning tasks such as SPARQL query answering. One such important analysis task is entity comparison, i.e., determining what are similarities and differences between two given entities in an RDF graph. For instance, in an RDF graph about drugs, we may want to compare Metamizole and Ibuprofen and automatically find out that they are similar in that they are both analgesics but, in contrast to Metamizole, Ibuprofen also has a considerable anti-inflammatory effect. Entity comparison is a widely used functionality available in many information systems, such as universities or product comparison websites. However, comparison is typically domain-specific and depends on a fixed set of aspects to compare. In this paper, we propose a formal framework for domain-independent entity comparison over RDF graphs. We model similarities and differences between entities as SPARQL queries satisfying certain additional properties, and propose algorithms for computing them

The Definability Abduction Problem for Data Exchange: abstract

Data exchange is the problem of transforming data structured according to a source schema into data structured according to a target schema, via a mapping specified by means of rules in the form of source-to-target tuple generating dependencies - rules whose body is a conjunction of atoms over the source schema and the head is a conjunction of atoms over the target schema, with possibly existential variables in the head. With this formalization, given a fixed source database, there might be more than one target databases satisfying a given mapping. That is, the target database is actually an incomplete database represented by a set of possible databases. Therefore, the problem of query answering the target data is inherently complex for general (non-positive) relational or aggregate queries